{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read data form csv\n",
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "## remove duplicate rows\n",
    "def unique(a): \n",
    "    order = np.lexsort(a.T)\n",
    "    a = a[order]\n",
    "    diff = np.diff(a, axis=0)\n",
    "    ui = np.ones(len(a), 'bool')\n",
    "    ui[1:] = (diff != 0).any(axis=1) \n",
    "    return a[ui]\n",
    "## read the the file saving premise\n",
    "def getpremise(wheel_type, batnum): \n",
    "#     name_folder = \"S:/Polyspace/R2020a/bin/work/grdsim_cluster\"\n",
    "    name_folder = \"C:/Users/Anthony Dave/Desktop/Undergraduate thesis/数据\"\n",
    "    names = 'w' + str(wheel_type) + 'batch_' + str(batnum) + '_premise.csv'\n",
    "    filename_premise = os.path.join(name_folder, names)\n",
    "    nppremise = np.loadtxt(open(filename_premise, \"rb\"), delimiter=\",\")\n",
    "    nppremise = unique(nppremise)\n",
    "    if wheel_type == 1:\n",
    "        dfpremise = pd.DataFrame(data=nppremise, columns=[\"grits_num\",\"shape\",\"trim_h\",\"omega\",\"h2w_ratio\",\n",
    "                                                        \"Rarea\",\"sigmah\",\"sigmasw\",\"fillet_mode\",\"Ra\",\"Cr\"])\n",
    "    elif wheel_type == 2:\n",
    "        dfpremise = pd.DataFrame(data=nppremise, columns=[\"grits_num\",\"theta\",\"SepGap\",\"RowGap\",\"k_dev\",\"shape\",\"trim_h\",\n",
    "                                                          \"omega\",\"h2w_ratio\",\"Rarea\",\"sigmah\",\"sigmasw\",\"fillet_mode\"\n",
    "                                                          ,\"Ra\",\"Cr\"])\n",
    "    return nppremise, dfpremise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>grits_num</th>\n",
       "      <th>theta</th>\n",
       "      <th>SepGap</th>\n",
       "      <th>RowGap</th>\n",
       "      <th>k_dev</th>\n",
       "      <th>shape</th>\n",
       "      <th>trim_h</th>\n",
       "      <th>omega</th>\n",
       "      <th>h2w_ratio</th>\n",
       "      <th>Rarea</th>\n",
       "      <th>sigmah</th>\n",
       "      <th>sigmasw</th>\n",
       "      <th>fillet_mode</th>\n",
       "      <th>Ra</th>\n",
       "      <th>Cr</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2400.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.050638</td>\n",
       "      <td>29612.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2400.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.051682</td>\n",
       "      <td>29824.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2400.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>6.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.107541</td>\n",
       "      <td>30415.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2400.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.057226</td>\n",
       "      <td>30591.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2400.0</td>\n",
       "      <td>80.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>9.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.053012</td>\n",
       "      <td>30655.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   grits_num  theta  SepGap  RowGap  k_dev  shape  trim_h  omega  h2w_ratio  \\\n",
       "0     2400.0   80.0     0.5     3.0    0.5    1.0     0.0    3.0        1.0   \n",
       "1     2400.0   80.0     0.5     3.0    0.5    1.0     0.0    6.0        1.0   \n",
       "2     2400.0   80.0     0.5     3.0    0.5    1.0     0.0    6.0        1.0   \n",
       "3     2400.0   80.0     0.5     3.0    0.5    1.0     0.0    3.0        1.0   \n",
       "4     2400.0   80.0     0.5     3.0    0.5    1.0     0.0    9.0        1.0   \n",
       "\n",
       "   Rarea  sigmah  sigmasw  fillet_mode        Ra       Cr  \n",
       "0   0.75     0.1      0.1          0.0  0.050638  29612.0  \n",
       "1   0.95     0.1      0.1          0.0  0.051682  29824.0  \n",
       "2   0.00     0.1      0.1          0.0  0.107541  30415.0  \n",
       "3   0.50     0.1      0.1          0.0  0.057226  30591.0  \n",
       "4   0.95     0.1      0.1          0.0  0.053012  30655.0  "
      ]
     },
     "execution_count": 364,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# choose the premise dataset\n",
    "wheel_type = 2\n",
    "batnum = 1\n",
    "nppremise, dfpremise = getpremise(wheel_type,batnum)\n",
    "dfpremise.head()\n",
    "# np.info(premisefile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 367,
   "metadata": {},
   "outputs": [],
   "source": [
    "## read conclusion data from csv\n",
    "def getdata(wheel_type, nppremise, data_type):\n",
    "    data_folder = \"C:/Users/Anthony Dave/Desktop/Undergraduate thesis/数据/1105effectofshape\"\n",
    "#     data_folder = \"C:/Users/Anthony Dave/Desktop/Undergraduate thesis/数据/1105effectofsigma\"\n",
    "    dataname = 'N'\n",
    "    dataname += str(np.int(nppremise[0]))\n",
    "    posi = 0\n",
    "    if wheel_type == 2:\n",
    "        posi = 4\n",
    "        dataname += ('_tgw' + str(np.int(nppremise[1])) +\n",
    "                              'kd' + (str(nppremise[4]) if nppremise[4] != 0 else str(np.int(nppremise[4]))) +\n",
    "                              'Sgap' + (str(nppremise[2]) if nppremise[2] != 0 else str(np.int(nppremise[2]))) +\n",
    "                              'Rgap' + (str(np.int(nppremise[3])) if nppremise[3] != 0 else str(np.int(nppremise[3]))))\n",
    "#     dataname += ['_w' + str(np.int(nppremise[0,3+posi])) + 'Rhw' + str(np.int(nppremise[0,4+posi])) + 'Rarea' + \n",
    "#                  str(nppremise[0,5+posi]) + 'FT' + str(np.int(nppremise[0,8+posi])) + data_type + '.csv']\n",
    "    dataname +=  ('w' + str(np.int(nppremise[3+posi])) + \n",
    "                  'Rarea' + (str(nppremise[5+posi]) if nppremise[5+posi] != 0 else str(np.int(nppremise[5+posi])))+\n",
    "                  'hsg' + (str(nppremise[6+posi]) if nppremise[6+posi] != 0 else str(np.int(nppremise[6+posi])))+\n",
    "                  'swsg' + (str(nppremise[7+posi]) if nppremise[7+posi] != 0 else str(np.int(nppremise[6+posi])))+\n",
    "                  data_type + '.csv')\n",
    "    filename_force = os.path.join(data_folder,dataname)\n",
    "    npdata = np.loadtxt(open(filename_force, \"rb\"), delimiter=\",\")\n",
    "    if data_type == '-GForce':\n",
    "        dfdata = pd.DataFrame(data=npdata, columns=[\"time\", \"Fn\", \"Ft\"])\n",
    "    return npdata, dfdata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 368,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_type = '-GForce'\n",
    "# data_type = '' # you should set the columns' names first\n",
    "npforce = []\n",
    "dfforce = []\n",
    "for i in range(0,len(nppremise)):\n",
    "    npfort, dffort = getdata(wheel_type, nppremise[i,:], data_type)\n",
    "    npforce.append(npfort)\n",
    "    dfforce.append(dffort)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 369,
   "metadata": {},
   "outputs": [],
   "source": [
    "# temporarily define\n",
    "threshold_down = 1.5*pow(10,-4)\n",
    "threshold_up = 3.5*pow(10,-4)\n",
    "grinding_forcen = []\n",
    "grinding_forcet = []\n",
    "for i in range(0,len(npforce)):\n",
    "    grinding_range = np.where(np.logical_and(npforce[i][:,0]>=threshold_down, npforce[i][:,0]<=threshold_up))\n",
    "    siz = len(grinding_range)\n",
    "    minnum = np.amin(grinding_range)\n",
    "    maxnum = np.amax(grinding_range)\n",
    "    grinding_forcen = np.append(grinding_forcen,(np.sum(npforce[i][minnum:maxnum,1])/siz))\n",
    "    grinding_forcet = np.append(grinding_forcet,(np.sum(npforce[i][minnum:maxnum,2])/siz))\n",
    "# np.info(grinding_forcen)\n",
    "# # np.shape(grinding_forcen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 370,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>omega</th>\n",
       "      <th>Rarea</th>\n",
       "      <th>Ra</th>\n",
       "      <th>Cr</th>\n",
       "      <th>Fn</th>\n",
       "      <th>Ft</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.75</td>\n",
       "      <td>0.050638</td>\n",
       "      <td>29612.0</td>\n",
       "      <td>4057.700116</td>\n",
       "      <td>1471.454796</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>6.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.051682</td>\n",
       "      <td>29824.0</td>\n",
       "      <td>4108.814296</td>\n",
       "      <td>1483.588376</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6.0</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.107541</td>\n",
       "      <td>30415.0</td>\n",
       "      <td>4176.070572</td>\n",
       "      <td>1433.054280</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.0</td>\n",
       "      <td>0.50</td>\n",
       "      <td>0.057226</td>\n",
       "      <td>30591.0</td>\n",
       "      <td>4210.577840</td>\n",
       "      <td>1536.573802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>9.0</td>\n",
       "      <td>0.95</td>\n",
       "      <td>0.053012</td>\n",
       "      <td>30655.0</td>\n",
       "      <td>4212.123072</td>\n",
       "      <td>1524.611404</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   omega  Rarea        Ra       Cr           Fn           Ft\n",
       "0    3.0   0.75  0.050638  29612.0  4057.700116  1471.454796\n",
       "1    6.0   0.95  0.051682  29824.0  4108.814296  1483.588376\n",
       "2    6.0   0.00  0.107541  30415.0  4176.070572  1433.054280\n",
       "3    3.0   0.50  0.057226  30591.0  4210.577840  1536.573802\n",
       "4    9.0   0.95  0.053012  30655.0  4212.123072  1524.611404"
      ]
     },
     "execution_count": 370,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data mining variance threshold\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "# def variance_threshold_selector(data, threshold=0.01):\n",
    "#     selector = VarianceThreshold(threshold)\n",
    "def variance_threshold_selector(data):\n",
    "    selector = VarianceThreshold()\n",
    "    selector.fit(data)\n",
    "    return data[data.columns[selector.get_support(indices=True)]]\n",
    "Xt = variance_threshold_selector(dfpremise)\n",
    "# prem = pd.DataFrame(Xt.iloc[:,[0,1,3]]) \n",
    "# conc = pd.DataFrame(Xt.iloc[:,2])\n",
    "# conc[\"Fn\"] = pd.DataFrame(data=np.transpose([grinding_forcen]), columns=[\"Fn\"])\n",
    "# conc[\"Ft\"] = pd.DataFrame(data=np.transpose([grinding_forcet]), columns=[\"Ft\"])\n",
    "Xt = pd.DataFrame(Xt)\n",
    "Xt[\"Fn\"] = pd.DataFrame(data=np.transpose([grinding_forcen]), columns=[\"Fn\"])\n",
    "Xt[\"Ft\"] = pd.DataFrame(data=np.transpose([grinding_forcet]), columns=[\"Ft\"])\n",
    "# Xt[\"Ra_abvoe_mean\"] = Xt['Ra'] > Xt['Ra'].mean()\n",
    "Xt.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import pearsonr\n",
    "\n",
    "def multivariate_pearsonr(X, y):\n",
    "    scores, pvalues = [], []\n",
    "    for column in range(X.shape[1]):\n",
    "        cur_score, cur_p = pearsonr(X[:,column], y)\n",
    "        scores.append(cur_score)\n",
    "        pvalues.append(cur_p)\n",
    "    return (np.array(scores), np.array(pvalues))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 360,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# pearson correlation\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# X = Xt[[\"omega\", \"Rarea\", \"Cr\"]].values\n",
    "X = Xt[[\"Rarea\", 'sigmah', 'sigmasw', \"Cr\"]].values\n",
    "for name in ['Ra','Fn','Ft']:\n",
    "    data_folder = r\"1105\"\n",
    "    output_filename = 'w' + str(wheel_type) + 'batch' + str(batnum) + '_' + name\n",
    "    fullpath1 = os.path.join(data_folder, 'pearson', output_filename + \".jpg\")\n",
    "    fullpath2 = os.path.join(data_folder, 'pearson', output_filename + \".csv\")\n",
    "    \n",
    "    y = (Xt[name] > Xt[name].mean()).values # temporarily define\n",
    "\n",
    "    transformer = SelectKBest(score_func=multivariate_pearsonr, k=3)\n",
    "    Xt_pearson = transformer.fit_transform(X, y)\n",
    "    \n",
    "    y = transformer.scores_\n",
    "    prenum = len(y)\n",
    "    x = np.arange(prenum)\n",
    "    \n",
    "    fig, ax = plt.subplots()\n",
    "    plt.bar(x, y)\n",
    "#     plt.xticks(x, ('omega', 'Rarea', 'Cr'))\n",
    "    plt.xticks(x, [\"Rarea\", 'sigmah', 'sigmasw', \"Cr\"])\n",
    "    ax.set_xlabel('premise')\n",
    "    ax.set_ylabel(name+'_Pearson')\n",
    "    plt.show()\n",
    "    fig.savefig(fullpath1)\n",
    "    np.savetxt(fullpath2, y)\n",
    "#     plt.close(fig)\n",
    "#     print(transformer.scores_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = Xt[[\"Rarea\", 'omega', \"Cr\"]].values\n",
    "name = 'Ra'\n",
    "y = (Xt[name] > Xt[name].mean()).values # temporarily define"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.8375      0.         43.73191924]\n"
     ]
    }
   ],
   "source": [
    "# k2\n",
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import chi2\n",
    "transformer = SelectKBest(score_func=chi2, k=3)\n",
    "Xt_chi2 = transformer.fit_transform(X, y)\n",
    "print(transformer.scores_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 281,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.34641016 0.52038181 0.31738713]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Rarea', 'sigmah', 'sigmasw', 'Cr', 'Ra', 'Fn', 'Ft'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "# print(prem.columns)\n",
    "# print(conc.columns)\n",
    "if batnum == 1:\n",
    "    columnsTitles = ['omega', 'Rarea', 'Cr', 'Ra', 'Fn', 'Ft']\n",
    "elif batnum == 2:\n",
    "    columnsTitles = ['Rarea', 'sigmah','sigmasw', 'Cr', 'Ra', 'Fn', 'Ft']\n",
    "Xt = Xt.reindex(columns=columnsTitles)\n",
    "print(Xt.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rarea'"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Xt.values[:,1]\n",
    "Xt.columns[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "from matplotlib import cm\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "def plotsave(xname,yname,zname,wheel_type,batum):\n",
    "    data_folder = r\"1105\"\n",
    "    output_filename = 'w' + str(wheel_type) + 'batch' + str(batnum) + xname + '&' + yname + '-' + zname\n",
    "    fullpath = os.path.join(data_folder, output_filename + \".jpg\")\n",
    "    \n",
    "    x = Xt[xname].values\n",
    "    y = Xt[yname].values\n",
    "    z = Xt[zname].values\n",
    "    \n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    ax = fig.gca(projection='3d')\n",
    "    surf = ax.plot_trisurf(x, y, z, cmap=cm.jet, linewidth=0)\n",
    "\n",
    "    plt.colorbar(surf,fraction=0.040, pad=0.04)\n",
    "    fig.tight_layout()\n",
    "    \n",
    "    angl = 40\n",
    "    if zname == 'Ft':\n",
    "        angl = 60\n",
    "    elif zname == 'Fn':\n",
    "        angl = -angl\n",
    "    if yname == 'Cr':\n",
    "        angl += 40\n",
    "    elif xname == 'Cr':\n",
    "        angl -= 30\n",
    "    ax.view_init(elev=35., azim=angl)\n",
    "    ax.set_xlabel(xname)\n",
    "    ax.set_ylabel(yname)\n",
    "    ax.set_zlabel(zname)\n",
    "    \n",
    "    # plt.show()\n",
    "    fig.savefig(fullpath)\n",
    "    plt.close(fig)\n",
    "    # ax.plot_trisurf(x, y, z, linewidth=0.2, antialiased=True)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# plot\n",
    "# for i in range(0,4):\n",
    "#     i1 = i\n",
    "#     if i == 3:\n",
    "#         i2 = 0\n",
    "#     else: i2 = i+1\n",
    "#     for j in range(4,7):\n",
    "#         plotsave(Xt.columns[i1],Xt.columns[i2],Xt.columns[j],wheel_type, batnum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
